// Generated from D:/desktop/code/gitee/dahuoyzs/compiler/src/test/java/antlr4/myantlrtest/g4/FishProtocol.g4 by ANTLR 4.13.1
package antlr4.myantlrtest.test.fishprotocol.gen;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class FishProtocolParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, IntEQ=7, LongEQ=8, FloatEQ=9, 
		DoubleEQ=10, StringEQ=11, BoolEQ=12, IntArrEQ=13, LongArrEQ=14, FloatArrEQ=15, 
		DoubleArrEQ=16, StringArrEQ=17, BoolArrEQ=18, IntArr=19, LongArr=20, FloatArr=21, 
		DoubleArr=22, StringArr=23, BoolArr=24, NetObject=25, IntLiteral=26, LongLiteral=27, 
		FloatLiteral=28, DoubleLiteral=29, BooleanLiteral=30, CharacterLiteral=31, 
		StringLiteral=32, NullLiteral=33;
	public static final int
		RULE_protocol = 0, RULE_params = 1, RULE_param = 2;
	private static String[] makeRuleNames() {
		return new String[] {
			"protocol", "params", "param"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'c'", "'['", "','", "']'", "'{'", "'}'", null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, "'null'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, "IntEQ", "LongEQ", "FloatEQ", 
			"DoubleEQ", "StringEQ", "BoolEQ", "IntArrEQ", "LongArrEQ", "FloatArrEQ", 
			"DoubleArrEQ", "StringArrEQ", "BoolArrEQ", "IntArr", "LongArr", "FloatArr", 
			"DoubleArr", "StringArr", "BoolArr", "NetObject", "IntLiteral", "LongLiteral", 
			"FloatLiteral", "DoubleLiteral", "BooleanLiteral", "CharacterLiteral", 
			"StringLiteral", "NullLiteral"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "FishProtocol.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public FishProtocolParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ProtocolContext extends ParserRuleContext {
		public TerminalNode IntLiteral() { return getToken(FishProtocolParser.IntLiteral, 0); }
		public ParamsContext params() {
			return getRuleContext(ParamsContext.class,0);
		}
		public ProtocolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_protocol; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterProtocol(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitProtocol(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitProtocol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProtocolContext protocol() throws RecognitionException {
		ProtocolContext _localctx = new ProtocolContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_protocol);
		try {
			setState(11);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(6);
				match(T__0);
				setState(7);
				match(IntLiteral);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(8);
				match(T__0);
				setState(9);
				match(IntLiteral);
				setState(10);
				params();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParamsContext extends ParserRuleContext {
		public List<ParamContext> param() {
			return getRuleContexts(ParamContext.class);
		}
		public ParamContext param(int i) {
			return getRuleContext(ParamContext.class,i);
		}
		public ParamsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_params; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterParams(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitParams(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitParams(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamsContext params() throws RecognitionException {
		ParamsContext _localctx = new ParamsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_params);
		int _la;
		try {
			setState(39);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(13);
				match(T__1);
				setState(14);
				param();
				setState(19);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__2) {
					{
					{
					setState(15);
					match(T__2);
					setState(16);
					param();
					}
					}
					setState(21);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(22);
				match(T__3);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(24);
				match(T__1);
				setState(25);
				match(T__3);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(26);
				match(T__4);
				setState(27);
				param();
				setState(32);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__2) {
					{
					{
					setState(28);
					match(T__2);
					setState(29);
					param();
					}
					}
					setState(34);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(35);
				match(T__5);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(37);
				match(T__4);
				setState(38);
				match(T__5);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParamContext extends ParserRuleContext {
		public ParamContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_param; }
	 
		public ParamContext() { }
		public void copyFrom(ParamContext ctx) {
			super.copyFrom(ctx);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IntEQContext extends ParamContext {
		public TerminalNode IntEQ() { return getToken(FishProtocolParser.IntEQ, 0); }
		public IntEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterIntEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitIntEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitIntEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class StringEQContext extends ParamContext {
		public TerminalNode StringEQ() { return getToken(FishProtocolParser.StringEQ, 0); }
		public StringEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterStringEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitStringEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitStringEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BooleanLiteralContext extends ParamContext {
		public TerminalNode BooleanLiteral() { return getToken(FishProtocolParser.BooleanLiteral, 0); }
		public BooleanLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterBooleanLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitBooleanLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitBooleanLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolEQContext extends ParamContext {
		public TerminalNode BoolEQ() { return getToken(FishProtocolParser.BoolEQ, 0); }
		public BoolEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterBoolEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitBoolEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitBoolEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IntArrContext extends ParamContext {
		public TerminalNode IntArr() { return getToken(FishProtocolParser.IntArr, 0); }
		public IntArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterIntArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitIntArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitIntArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LongEQContext extends ParamContext {
		public TerminalNode LongEQ() { return getToken(FishProtocolParser.LongEQ, 0); }
		public LongEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterLongEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitLongEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitLongEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoubleArrEQContext extends ParamContext {
		public TerminalNode DoubleArrEQ() { return getToken(FishProtocolParser.DoubleArrEQ, 0); }
		public DoubleArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterDoubleArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitDoubleArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitDoubleArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolArrEQContext extends ParamContext {
		public TerminalNode BoolArrEQ() { return getToken(FishProtocolParser.BoolArrEQ, 0); }
		public BoolArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterBoolArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitBoolArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitBoolArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoubleArrContext extends ParamContext {
		public TerminalNode DoubleArr() { return getToken(FishProtocolParser.DoubleArr, 0); }
		public DoubleArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterDoubleArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitDoubleArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitDoubleArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class StringArrContext extends ParamContext {
		public TerminalNode StringArr() { return getToken(FishProtocolParser.StringArr, 0); }
		public StringArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterStringArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitStringArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitStringArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IntLiteralContext extends ParamContext {
		public TerminalNode IntLiteral() { return getToken(FishProtocolParser.IntLiteral, 0); }
		public IntLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterIntLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitIntLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitIntLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class IntArrEQContext extends ParamContext {
		public TerminalNode IntArrEQ() { return getToken(FishProtocolParser.IntArrEQ, 0); }
		public IntArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterIntArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitIntArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitIntArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class StringArrEQContext extends ParamContext {
		public TerminalNode StringArrEQ() { return getToken(FishProtocolParser.StringArrEQ, 0); }
		public StringArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterStringArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitStringArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitStringArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FloatEQContext extends ParamContext {
		public TerminalNode FloatEQ() { return getToken(FishProtocolParser.FloatEQ, 0); }
		public FloatEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterFloatEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitFloatEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitFloatEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LongArrContext extends ParamContext {
		public TerminalNode LongArr() { return getToken(FishProtocolParser.LongArr, 0); }
		public LongArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterLongArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitLongArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitLongArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class BoolArrContext extends ParamContext {
		public TerminalNode BoolArr() { return getToken(FishProtocolParser.BoolArr, 0); }
		public BoolArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterBoolArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitBoolArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitBoolArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LongLiteralContext extends ParamContext {
		public TerminalNode LongLiteral() { return getToken(FishProtocolParser.LongLiteral, 0); }
		public LongLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterLongLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitLongLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitLongLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FloatLiteralContext extends ParamContext {
		public TerminalNode FloatLiteral() { return getToken(FishProtocolParser.FloatLiteral, 0); }
		public FloatLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterFloatLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitFloatLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitFloatLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FloatArrContext extends ParamContext {
		public TerminalNode FloatArr() { return getToken(FishProtocolParser.FloatArr, 0); }
		public FloatArrContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterFloatArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitFloatArr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitFloatArr(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class StringLiteralContext extends ParamContext {
		public TerminalNode StringLiteral() { return getToken(FishProtocolParser.StringLiteral, 0); }
		public StringLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterStringLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitStringLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitStringLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NetObjectContext extends ParamContext {
		public TerminalNode NetObject() { return getToken(FishProtocolParser.NetObject, 0); }
		public NetObjectContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterNetObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitNetObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitNetObject(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoubleLiteralContext extends ParamContext {
		public TerminalNode DoubleLiteral() { return getToken(FishProtocolParser.DoubleLiteral, 0); }
		public DoubleLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterDoubleLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitDoubleLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitDoubleLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class LongArrEQContext extends ParamContext {
		public TerminalNode LongArrEQ() { return getToken(FishProtocolParser.LongArrEQ, 0); }
		public LongArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterLongArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitLongArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitLongArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class NullLiteralContext extends ParamContext {
		public TerminalNode NullLiteral() { return getToken(FishProtocolParser.NullLiteral, 0); }
		public NullLiteralContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterNullLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitNullLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitNullLiteral(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class DoubleEQContext extends ParamContext {
		public TerminalNode DoubleEQ() { return getToken(FishProtocolParser.DoubleEQ, 0); }
		public DoubleEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterDoubleEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitDoubleEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitDoubleEQ(this);
			else return visitor.visitChildren(this);
		}
	}
	@SuppressWarnings("CheckReturnValue")
	public static class FloatArrEQContext extends ParamContext {
		public TerminalNode FloatArrEQ() { return getToken(FishProtocolParser.FloatArrEQ, 0); }
		public FloatArrEQContext(ParamContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).enterFloatArrEQ(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof FishProtocolListener ) ((FishProtocolListener)listener).exitFloatArrEQ(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof FishProtocolVisitor ) return ((FishProtocolVisitor<? extends T>)visitor).visitFloatArrEQ(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamContext param() throws RecognitionException {
		ParamContext _localctx = new ParamContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_param);
		try {
			setState(67);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntLiteral:
				_localctx = new IntLiteralContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(41);
				match(IntLiteral);
				}
				break;
			case LongLiteral:
				_localctx = new LongLiteralContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(42);
				match(LongLiteral);
				}
				break;
			case FloatLiteral:
				_localctx = new FloatLiteralContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(43);
				match(FloatLiteral);
				}
				break;
			case DoubleLiteral:
				_localctx = new DoubleLiteralContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(44);
				match(DoubleLiteral);
				}
				break;
			case StringLiteral:
				_localctx = new StringLiteralContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(45);
				match(StringLiteral);
				}
				break;
			case BooleanLiteral:
				_localctx = new BooleanLiteralContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(46);
				match(BooleanLiteral);
				}
				break;
			case NullLiteral:
				_localctx = new NullLiteralContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(47);
				match(NullLiteral);
				}
				break;
			case IntArr:
				_localctx = new IntArrContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(48);
				match(IntArr);
				}
				break;
			case LongArr:
				_localctx = new LongArrContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(49);
				match(LongArr);
				}
				break;
			case FloatArr:
				_localctx = new FloatArrContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(50);
				match(FloatArr);
				}
				break;
			case DoubleArr:
				_localctx = new DoubleArrContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(51);
				match(DoubleArr);
				}
				break;
			case StringArr:
				_localctx = new StringArrContext(_localctx);
				enterOuterAlt(_localctx, 12);
				{
				setState(52);
				match(StringArr);
				}
				break;
			case BoolArr:
				_localctx = new BoolArrContext(_localctx);
				enterOuterAlt(_localctx, 13);
				{
				setState(53);
				match(BoolArr);
				}
				break;
			case IntEQ:
				_localctx = new IntEQContext(_localctx);
				enterOuterAlt(_localctx, 14);
				{
				setState(54);
				match(IntEQ);
				}
				break;
			case LongEQ:
				_localctx = new LongEQContext(_localctx);
				enterOuterAlt(_localctx, 15);
				{
				setState(55);
				match(LongEQ);
				}
				break;
			case FloatEQ:
				_localctx = new FloatEQContext(_localctx);
				enterOuterAlt(_localctx, 16);
				{
				setState(56);
				match(FloatEQ);
				}
				break;
			case DoubleEQ:
				_localctx = new DoubleEQContext(_localctx);
				enterOuterAlt(_localctx, 17);
				{
				setState(57);
				match(DoubleEQ);
				}
				break;
			case StringEQ:
				_localctx = new StringEQContext(_localctx);
				enterOuterAlt(_localctx, 18);
				{
				setState(58);
				match(StringEQ);
				}
				break;
			case BoolEQ:
				_localctx = new BoolEQContext(_localctx);
				enterOuterAlt(_localctx, 19);
				{
				setState(59);
				match(BoolEQ);
				}
				break;
			case IntArrEQ:
				_localctx = new IntArrEQContext(_localctx);
				enterOuterAlt(_localctx, 20);
				{
				setState(60);
				match(IntArrEQ);
				}
				break;
			case LongArrEQ:
				_localctx = new LongArrEQContext(_localctx);
				enterOuterAlt(_localctx, 21);
				{
				setState(61);
				match(LongArrEQ);
				}
				break;
			case FloatArrEQ:
				_localctx = new FloatArrEQContext(_localctx);
				enterOuterAlt(_localctx, 22);
				{
				setState(62);
				match(FloatArrEQ);
				}
				break;
			case DoubleArrEQ:
				_localctx = new DoubleArrEQContext(_localctx);
				enterOuterAlt(_localctx, 23);
				{
				setState(63);
				match(DoubleArrEQ);
				}
				break;
			case StringArrEQ:
				_localctx = new StringArrEQContext(_localctx);
				enterOuterAlt(_localctx, 24);
				{
				setState(64);
				match(StringArrEQ);
				}
				break;
			case BoolArrEQ:
				_localctx = new BoolArrEQContext(_localctx);
				enterOuterAlt(_localctx, 25);
				{
				setState(65);
				match(BoolArrEQ);
				}
				break;
			case NetObject:
				_localctx = new NetObjectContext(_localctx);
				enterOuterAlt(_localctx, 26);
				{
				setState(66);
				match(NetObject);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u0001!F\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002"+
		"\u0007\u0002\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+
		"\u0003\u0000\f\b\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0005\u0001\u0012\b\u0001\n\u0001\f\u0001\u0015\t\u0001\u0001\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0005\u0001\u001f\b\u0001\n\u0001\f\u0001\"\t\u0001\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001(\b\u0001\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0003\u0002D\b\u0002\u0001\u0002\u0000\u0000\u0003\u0000"+
		"\u0002\u0004\u0000\u0000a\u0000\u000b\u0001\u0000\u0000\u0000\u0002\'"+
		"\u0001\u0000\u0000\u0000\u0004C\u0001\u0000\u0000\u0000\u0006\u0007\u0005"+
		"\u0001\u0000\u0000\u0007\f\u0005\u001a\u0000\u0000\b\t\u0005\u0001\u0000"+
		"\u0000\t\n\u0005\u001a\u0000\u0000\n\f\u0003\u0002\u0001\u0000\u000b\u0006"+
		"\u0001\u0000\u0000\u0000\u000b\b\u0001\u0000\u0000\u0000\f\u0001\u0001"+
		"\u0000\u0000\u0000\r\u000e\u0005\u0002\u0000\u0000\u000e\u0013\u0003\u0004"+
		"\u0002\u0000\u000f\u0010\u0005\u0003\u0000\u0000\u0010\u0012\u0003\u0004"+
		"\u0002\u0000\u0011\u000f\u0001\u0000\u0000\u0000\u0012\u0015\u0001\u0000"+
		"\u0000\u0000\u0013\u0011\u0001\u0000\u0000\u0000\u0013\u0014\u0001\u0000"+
		"\u0000\u0000\u0014\u0016\u0001\u0000\u0000\u0000\u0015\u0013\u0001\u0000"+
		"\u0000\u0000\u0016\u0017\u0005\u0004\u0000\u0000\u0017(\u0001\u0000\u0000"+
		"\u0000\u0018\u0019\u0005\u0002\u0000\u0000\u0019(\u0005\u0004\u0000\u0000"+
		"\u001a\u001b\u0005\u0005\u0000\u0000\u001b \u0003\u0004\u0002\u0000\u001c"+
		"\u001d\u0005\u0003\u0000\u0000\u001d\u001f\u0003\u0004\u0002\u0000\u001e"+
		"\u001c\u0001\u0000\u0000\u0000\u001f\"\u0001\u0000\u0000\u0000 \u001e"+
		"\u0001\u0000\u0000\u0000 !\u0001\u0000\u0000\u0000!#\u0001\u0000\u0000"+
		"\u0000\" \u0001\u0000\u0000\u0000#$\u0005\u0006\u0000\u0000$(\u0001\u0000"+
		"\u0000\u0000%&\u0005\u0005\u0000\u0000&(\u0005\u0006\u0000\u0000\'\r\u0001"+
		"\u0000\u0000\u0000\'\u0018\u0001\u0000\u0000\u0000\'\u001a\u0001\u0000"+
		"\u0000\u0000\'%\u0001\u0000\u0000\u0000(\u0003\u0001\u0000\u0000\u0000"+
		")D\u0005\u001a\u0000\u0000*D\u0005\u001b\u0000\u0000+D\u0005\u001c\u0000"+
		"\u0000,D\u0005\u001d\u0000\u0000-D\u0005 \u0000\u0000.D\u0005\u001e\u0000"+
		"\u0000/D\u0005!\u0000\u00000D\u0005\u0013\u0000\u00001D\u0005\u0014\u0000"+
		"\u00002D\u0005\u0015\u0000\u00003D\u0005\u0016\u0000\u00004D\u0005\u0017"+
		"\u0000\u00005D\u0005\u0018\u0000\u00006D\u0005\u0007\u0000\u00007D\u0005"+
		"\b\u0000\u00008D\u0005\t\u0000\u00009D\u0005\n\u0000\u0000:D\u0005\u000b"+
		"\u0000\u0000;D\u0005\f\u0000\u0000<D\u0005\r\u0000\u0000=D\u0005\u000e"+
		"\u0000\u0000>D\u0005\u000f\u0000\u0000?D\u0005\u0010\u0000\u0000@D\u0005"+
		"\u0011\u0000\u0000AD\u0005\u0012\u0000\u0000BD\u0005\u0019\u0000\u0000"+
		"C)\u0001\u0000\u0000\u0000C*\u0001\u0000\u0000\u0000C+\u0001\u0000\u0000"+
		"\u0000C,\u0001\u0000\u0000\u0000C-\u0001\u0000\u0000\u0000C.\u0001\u0000"+
		"\u0000\u0000C/\u0001\u0000\u0000\u0000C0\u0001\u0000\u0000\u0000C1\u0001"+
		"\u0000\u0000\u0000C2\u0001\u0000\u0000\u0000C3\u0001\u0000\u0000\u0000"+
		"C4\u0001\u0000\u0000\u0000C5\u0001\u0000\u0000\u0000C6\u0001\u0000\u0000"+
		"\u0000C7\u0001\u0000\u0000\u0000C8\u0001\u0000\u0000\u0000C9\u0001\u0000"+
		"\u0000\u0000C:\u0001\u0000\u0000\u0000C;\u0001\u0000\u0000\u0000C<\u0001"+
		"\u0000\u0000\u0000C=\u0001\u0000\u0000\u0000C>\u0001\u0000\u0000\u0000"+
		"C?\u0001\u0000\u0000\u0000C@\u0001\u0000\u0000\u0000CA\u0001\u0000\u0000"+
		"\u0000CB\u0001\u0000\u0000\u0000D\u0005\u0001\u0000\u0000\u0000\u0005"+
		"\u000b\u0013 \'C";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}